Hvordan kan jeg fjerne et bestemt element fra et array?

1
2
3
4
Næste
Find indekset for det array-element, du vil fjerne ved hjælp af indexOf, og fjern det indeks med splejsning.
Splice () -metoden ændrer indholdet af en matrix ved at fjerne
eksisterende elementer og / eller tilføjelse af nye elementer.
const array = [2, 5, 9];
console.log (array);
const index = array.indexOf (5);
hvis (indeks> -1) {
array.splice (indeks, 1);
}
// array = [2, 9]
console.log (array);
Den anden parameter for splejsning er antallet af elementer, der skal fjernes. Bemærk, at splejsning ændrer arrayet på plads og returnerer et nyt array, der indeholder de elementer, der er blevet fjernet.
Af grunden til fuldstændighed er her funktioner. Den første funktion fjerner kun en enkelt forekomst (dvs. fjerner den første kamp på 5 fra [2,5,9,1,5,8,5]), mens den anden funktion fjerner alle forekomster:
funktion removeItemOnce (arr, værdi) {
var index = arr.indexOf (værdi);
hvis (indeks> -1) {
arr.splice (indeks, 1);
}
returnere arr;
}
funktion removeItemAll (arr, værdi) {
var i = 0;
mens (i  = 0; i--) {
hvis (matrix [i] === nummer) {
array.splice (i, 1);
}
}
Hvis du bare vil oprette elementet i indeks, eksisterer jeg ikke længere, men du vil ikke have, at indekserne på de andre elementer skal ændres:
slet array [i];
|
Redigeret den 2016 oktober
Gør det simpelt, intuitivt og eksplicit (Occams barbermaskine)
Gør det uforanderligt (original array forbliver uændret)
Gør det med standard JavaScript-funktioner, hvis din browser ikke understøtter dem - brug polyfill
I dette kodeeksempel bruger jeg funktionen "array.filter (...)" til at fjerne uønskede emner fra en matrix. Denne funktion ændrer ikke det oprindelige array og opretter en ny. Hvis din browser ikke understøtter denne funktion (f.eks. Internet Explorer før version 9 eller Firefox før version 1.5), skal du overveje at bruge filterpolyfyld fra Mozilla.
Fjernelse af element (ECMA-262 Edition 5-kode aka oldstyle JavaScript)
var værdi = 3
var arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (funktion (element) {
returvare! == værdi
})
console.log (arr)
// [1, 2, 4, 5]
Fjernelse af element (ECMAScript 6-kode)
lad værdi = 3
lad arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (item => item! == værdi)
console.log (arr)
// [1, 2, 4, 5]
VIGTIGT ECMAScript 6 "() => {}" syntaks til pilfunktion understøttes overhovedet ikke i Internet Explorer, Chrome før version 45, Firefox før version 22 og Safari før version 10. For at bruge ECMAScript 6-syntaks i gamle browsere kan du bruge BabelJS.
Fjernelse af flere emner (ECMAScript 7-kode)
En yderligere fordel ved denne metode er, at du kan fjerne flere emner
lad forDeletion = [2, 3, 5]
lad arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (item =>! forDeletion.includes (item))
// !!! Læs nedenfor om array.includes (...) support !!!
console.log (arr)
// [1, 4]
VIGTIGT "array.includes (...)" -funktionen understøttes slet ikke i Internet Explorer, Chrome før 47-version, Firefox før 43-version, Safari før 9-version og Edge før 14-version, så her er polyfill fra Mozilla.
Fjernelse af flere emner (i fremtiden måske)
Hvis forslaget "Denne bindende syntaks" nogensinde accepteres, kan du gøre dette:
// array-lib.js
eksportfunktion fjern (... forDeletion) {
returner dette.filter (item =>! forDeletion.includes (item))
}
// main.js
importer {remove} fra './array-lib.js'
lad arr = [1, 2, 3, 4, 5, 3]
// :: Dette bindende syntaksforslag
// bruger "fjern" funktion som "virtuel metode"
// uden at udvide Array.prototype
arr = arr :: fjern (2, 3, 5)
console.log (arr)
// [1, 4]
Prøv det selv i BabelJS :)
Reference
Array.prototype.includes
Funktionel sammensætning
|
Det afhænger af, om du vil beholde et tomt sted eller ej.
Hvis du vil have en tom plads:
array [index] = udefineret;
Hvis du ikke vil have en tom plads:
// For at beholde originalen:
// oldArray = [... array];
// Dette ændrer arrayet.
array.splice (indeks, 1);
Og hvis du har brug for værdien af ​​den vare, kan du bare gemme det returnerede matrixelement:
var værdi = array.splice (indeks, 1) [0];
Hvis du vil fjerne i begge ender af arrayet, kan du bruge array.pop () til den sidste eller array.shift () til den første (begge returnerer også elementets værdi).
Hvis du ikke kender elementets indeks, kan du bruge array.indexOf (item) til at få det (i et if () for at få et element eller et stykke tid () for at få dem alle). array.indexOf (item) returnerer enten indekset eller -1, hvis det ikke findes.
|
En ven havde problemer i Internet Explorer 8 og viste mig, hvad han gjorde. Jeg fortalte ham, at det var forkert, og han fortalte mig, at han fik svarether. Det aktuelle topsvar fungerer ikke i alle browsere (f.eks. Internet Explorer 8), og det fjerner kun den første forekomst af elementet.
Fjern ALLE forekomster fra en matrix
funktion array_remove_index_by_value (arr, element)
{
for (var i = arr. længde; i--;)
{
hvis (arr [i] === vare) {arr.splice (i, 1);}
}
}
Det løber gennem arrayet bagud (da indekser og længde vil ændre sig, når elementer fjernes) og fjerner elementet, hvis det findes. Det fungerer i alle browsere.
|
Der er to hovedtilgange:
splejsning (): anArray.splice (indeks, 1);
slet: slet anArray [indeks];
Vær forsigtig, når du bruger delete til en matrix. Det er godt til at slette attributter af objekter, men ikke så godt for arrays. Det er bedre at bruge splejsning til arrays.
Husk, at når du bruger delete til en matrix, kan du få forkerte resultater for anArray.length. Med andre ord, sletning fjerner elementet, men det opdaterer ikke værdien af ​​længdeegenskaben.
Du kan også forvente at have huller i indeksnumre efter brug af sletning, f.eks. du kan ende med at have indeks 1, 3, 4, 8, 9 og 11 og længde, som det var før du brugte delete. I så fald ville alt indekseret for sløjfer gå ned, da indekser ikke længere er sekventielle.
Hvis du er tvunget til at bruge slet af en eller anden grund, skal du bruge til hver sløjfe, når du har brug for at gennemgå arrays. Faktisk skal du altid undgå at bruge indekseret til sløjfer, hvis det er muligt. På den måde ville koden være mere robust og mindre tilbøjelig til problemer med indekser.
|
Array.prototype.remove_by_value = funktion (val) {
for (var i = 0; i  række.id === 5);
var fjernet = helper.remove (arr, række => row.name.startsWith ('BMW'));
##Definition
var hjælper = {
// Fjern og returner den første forekomst
removeOne: funktion (array, predikat) {
for (var i = 0; i  [2, 3, 4]
|
Du kan bruge ES6. For eksempel for at slette værdien '3' i dette tilfælde:
var array = ['1', '2', '3', '4', '5', '6']
var newArray = array.filter ((værdi) => værdi! = '3');
console.log (newArray);
Output:
["1", "2", "4", "5", "6"]
|
Hvis du vil have et nyt array med de slettede positioner fjernet, kan du altid slette det specifikke element og filtrere arrayet. Det har muligvis brug for en udvidelse af array-objektet til browsere, der ikke implementerer filtermetoden, men på lang sigt er det lettere, da alt hvad du gør er dette:
var my_array = [1, 2, 3, 4, 5, 6];
slet min_array [4];
console.log (my_array.filter (funktion (a) {return typeof a! == 'udefineret';}));
Den skal vise [1, 2, 3, 4, 6].
|
Her er et par måder at fjerne et element fra et array ved hjælp af JavaScript.
Al den beskrevne metode muterer ikke den oprindelige matrix og opretter i stedet en ny.
Hvis du kender indekset for en vare
Antag at du har en matrix, og du vil fjerne et element i position i.
En metode er at bruge skive ():
const items = ['a', 'b', 'c', 'd', 'e', ​​'f']
konst i = 3
const filteredItems = items.slice (0, i) .concat (items.slice (i + 1, items.length))
console.log (filteredItems)
slice () opretter et nyt array med de indekser, det modtager. Vi opretter simpelthen et nyt array, fra start til det indeks, vi vil fjerne, og sammenkæder et andet array fra den første position efter den, vi fjernede til slutningen af ​​arrayet.
Hvis du kender værdien
I dette tilfælde er en god mulighed at bruge filter (), som giver en mere deklarativ tilgang:
const items = ['a', 'b', 'c', 'd', 'e', ​​'f']
const valueToRemove = 'c'
const filteredItems = items.filter (item => item! == valueToRemove)
console.log (filteredItems)
Dette bruger ES6-pilens funktioner. Du kan bruge de traditionelle funktioner til at understøtte ældre browsere:
const items = ['a', 'b', 'c', 'd', 'e', ​​'f']
const valueToRemove = 'c'
const filteredItems = items.filter (funktion (item) {
returnere vare! == valueToRemove
})
console.log (filteredItems)
eller du kan bruge Babel og transpilere ES6-koden tilbage til ES5 for at gøre den mere fordøjelig for gamle browsere, men skriv alligevel moderne JavaScript i din kode.
Fjernelse af flere emner
Hvad hvis du i stedet for et enkelt emne vil fjerne mange emner?
Lad os finde den enkleste løsning.
Efter indeks
Du kan bare oprette en funktion og fjerne emner i serien:
const items = ['a', 'b', 'c', 'd', 'e', ​​'f']
const removeItem = (emner, i) =>
items.slice (0, i-1) .concat (items.slice (i, items.length))
lad filteredItems = removeItem (emner, 3)
filteredItems = removeItem (filteredItems, 5)
// ["a", "b", "c", "d"]
console.log (filteredItems)
Efter værdi
Du kan søge efter inkludering i tilbagekaldsfunktionen:
const items = ['a', 'b', 'c', 'd', 'e', ​​'f']
const valuesToRemove = ['c', 'd']
const filteredItems = items.filter (item =>! valuesToRemove.includes (item))
// ["a", "b", "e", "f"]
console.log (filteredItems)
Undgå at mutere det originale array
splice () (må ikke forveksles med udsnit ()) muterer den oprindelige matrix og bør undgås.
(oprindeligt indsendt på mit websted https://flaviocopes.com/how-to-remove-item-from-array/)
|
Tjek denne kode. Det fungerer i alle større browsere.
remove_item = funktion (arr, værdi) {
var b = '';
for (b i arr) {
hvis (arr [b] === værdi) {
arr.splice (b, 1);
pause;
}
}
returnere arr;
};
Ring til denne funktion
remove_item (array, værdi);
|
ES6 & uden mutation: (oktober 2016)
const removeByIndex = (liste, indeks) =>
[
... list.slice (0, indeks),
... list.slice (indeks + 1)
];
output = removeByIndex ([33,22,11,44], 1) // => [33,11,44]
console.log (output)
|
Du kan bruge lodash _.pull (mutate array), _.pullAt (mutate array) eller _.without (muterer ikke array),
var array1 = ['a', 'b', 'c', 'd']
_.pull (array1, 'c')
console.log (array1) // ['a', 'b', 'd']
var array2 = ['e', 'f', 'g', 'h']
_.pullAt (array2, 0)
console.log (array2) // ['f', 'g', 'h']
var array3 = ['i', 'j', 'k', 'l']
var newArray = _.without (array3, 'i') // ['j', 'k', 'l']
console.log (array3) // ['i', 'j', 'k', 'l']
|
Fjernelse af et bestemt element / streng fra en matrix kan gøres i en one-liner:
theArray.splice (theArray.indexOf ("stringToRemoveFromArray"), 1);
hvor:
theArray: det array, du vil fjerne noget bestemt fra
stringToRemoveFromArray: den streng, du vil fjerne, og 1 er mængden af ​​elementer, du vil fjerne.
BEMÆRK: Hvis "stringToRemoveFromArray" ikke findes i arrayet, fjernes dette sidste element i arrayet.
Det er altid god praksis at kontrollere, om elementet findes i dit array først, før det fjernes.
hvis (theArray.indexOf ("stringToRemoveFromArray")> = 0) {
theArray.splice (theArray.indexOf ("stringToRemoveFromArray"), 1);
}
Hvis du har adgang til nyere Ecmascript-versioner på din klients computere (ADVARSEL fungerer muligvis ikke på ældre stationer):
var array = ['1', '2', '3', '4', '5', '6']
var newArray = array.filter ((værdi) => værdi! = '3');
Hvor '3' er den værdi, du vil fjerne fra arrayet.
Arrayet blev derefter: ['1', '2', '4', '5', '6']
|
OK, for eksempel har du nedenstående matrix:
var num = [1, 2, 3, 4, 5];
Og vi vil slette nummer 4. Du kan blot bruge nedenstående kode:
num.splice (num.indexOf (4), 1); // num vil være [1, 2, 3, 5];
Hvis du genbruger denne funktion, skriver du en genanvendelig funktion, der vil blive knyttet til den oprindelige matrixfunktion som nedenfor:
Array.prototype.remove = Array.prototype.remove || funktion (x) {
const i = this.indexOf (x);
hvis (i === - 1)
Vend tilbage;
this.splice (i, 1); // num.remove (5) === [1, 2, 3];
}
Men hvad med, hvis du har nedenstående array i stedet for et par [5] i arrayet?
var num = [5, 6, 5, 4, 5, 1, 5];
Vi har brug for en løkke for at kontrollere dem alle, men en nemmere og mere effektiv måde er at bruge indbyggede JavaScript-funktioner, så vi skriver en funktion, der bruger et filter som nedenfor i stedet:
const _removeValue = (arr, x) => arr.filter (n => n! == x);
// _ removeValue ([1, 2, 3, 4, 5, 5, 6, 5], 5) // Returner [1, 2, 3, 4, 6]
Der er også tredjepartsbiblioteker, som hjælper dig med at gøre dette, som Lodash eller Underscore. For flere oplysninger, se lodash _.pull, _.pullAt eller _.without.
|
Ydeevne
I dag (2019-12-09) udfører jeg præstationstest på macOS v10.13.6 (High Sierra) for valgte løsninger. Jeg viser delete (A), men jeg bruger den ikke i sammenligning med andre metoder, fordi den efterlod tom plads i arrayet.
Konklusionerne
den hurtigste løsning er array.splice (C) (undtagen Safari til små arrays, hvor den har anden gang)
for store arrays er array.slice + splejsning (H) den hurtigste uforanderlige løsning til Firefox og Safari; Array.from (B) er hurtigst i Chrome
mutable løsninger er normalt 1,5x-6x hurtigere end uforanderlige
for små borde på Safari er overraskende den ændrede løsning (C) langsommere end den uforanderlige løsning (G)
detaljer
I test fjerner jeg midterelementet fra arrayet på forskellige måder. A, C-løsninger er på plads. B-, D-, E-, F-, G-, H-opløsningerne er uforanderlige.
Resultater for matrix med 10 elementer
I Chrome er array.splice (C) den hurtigste løsning på stedet. Array.filter (D) er den hurtigste uforanderlige løsning. Den langsomste er array.slice (F). Du kan udføre testen på din maskine her.
Resultater for matrix med 1.000.000 elementer
I Chrome er array.splice (C) den hurtigste løsning på stedet (sletningen (C) ligner hurtigt - men den efterlod en tom plads i arrayet (så den ikke udfører en 'fuld fjernelse')). Array.slice-splice (H) er den hurtigste uforanderlige løsning. Den langsomste er array.filter (D og E). Du kan udføre testen på din maskine her.
var a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
var log = (letter, array) => console.log (letter, array.join `,`);
funktion A (matrix) {
var index = array.indexOf (5);
slet array [index];
log ('A', array);
}
funktion B (matrix) {
var index = array.indexOf (5);
var arr = Array.from (array);
arr.splice (indeks, 1)
log ('B', arr);
}
funktion C (matrix) {
var index = array.indexOf (5);
array.splice (indeks, 1);
log ('C', array);
}
funktion D (matrix) {
var arr = array.filter (item => item! == 5)
log ('D', arr);
}
funktion E (matrix) {
var index = array.indexOf (5);
var arr = array.filter ((element, i) => i! == indeks)
log ('E', arr);
}
funktion F (matrix) {
var index = array.indexOf (5);
var arr = array.slice (0, index) .concat (array.slice (index + 1))
log ('F', arr);
}
funktion G (matrix) {
var index = array.indexOf (5);
var arr = [... array.slice (0, index), ... array.slice (index + 1)]
log ('G', arr);
}
funktion H (matrix) {
var index = array.indexOf (5);
var arr = array.slice (0);
arr.splice (indeks, 1);
log ('H', arr);
}
A ([... a]);
B ([... a]);
C ([... a]);
D ([... a]);
E ([... a]);
F ([... a]);
G ([... a]);
H ([... a]);
Dette uddrag præsenterer kun kode, der bruges i præstationstest - det udfører ikke selv test.
Sammenligning for browsere: Chrome v78.0.0, Safari v13.0.4 og Firefox v71.0.0
|
Jeg er ret ny på JavaScript og havde brug for denne funktionalitet. Jeg skrev bare dette:
funktion removeFromArray (array, item, index) {
mens ((index = array.indexOf (item))> -1) {
array.splice (indeks, 1);
}
}
Så når jeg vil bruge det:
// Opsæt nogle dummy-data
var dummyObj = {navn: "meow"};
var dummyArray = [dummyObj, "item1", "item1", "item2"];
// Fjern dummy-data
removeFromArray (dummyArray, dummyObj);
removeFromArray (dummyArray, "item2");
Output - Som forventet.
["item1", "item1"]
Du har muligvis andre behov end jeg, så du kan let ændre detder passer til dem. Jeg håber, det hjælper nogen.
|
Hvis du har komplekse objekter i arrayet, kan du bruge filtre?
I situationer hvor $ .inArray eller array.splice ikke er så let at bruge. Især hvis objekterne måske er lave i arrayet.
F.eks. hvis du har et objekt med et Id-felt, og du vil have objektet fjernet fra et array:
this.array = this.array.filter (funktion (element, i) {
returner element.id! == idToRemove;
});
|
Jeg vil svare baseret på ECMAScript 6. Antag, at du har en matrix som nedenfor:
lad arr = [1,2,3,4];
Hvis du vil slette ved et specielt indeks som 2, skal du skrive nedenstående kode:
arr.splice (2, 1); // => arr blev [1,2,4]
Men hvis du vil slette et specielt element som 3, og du ikke kender dets indeks, skal du gøre som nedenfor:
arr = arr.filter (e => e! == 3); // => arr blev [1,2,4]
Tip: Brug en pilefunktion til at ringe tilbage, medmindre du får et tomt array.
|
Opdatering: Denne metode anbefales kun, hvis du ikke kan bruge ECMAScript 2015 (tidligere kendt som ES6). Hvis du kan bruge det, giver andre svar her meget pænere implementeringer.
Denne kerne her løser dit problem og sletter også alle forekomster af argumentet i stedet for kun 1 (eller en bestemt værdi).
Array.prototype.destroy = funktion (obj) {
// Returner null, hvis ingen objekter blev fundet og fjernet
var ødelagt = null;
for (var i = 0; i  3
x ødelægge (falsk); // => falsk
x; // => [1, 2, sand, udefineret]
x ødelægge (sandt); // => sandt
x ødelægge (udefineret); // => udefineret
x; // => [1, 2]
x ødelægge (3); // => null
x; // => [1, 2]
|
ES10-opdatering
Dette indlæg opsummerer almindelige tilgange til fjernelse af element fra array fra ECMAScript 2019 (ES10).
1. Generelle sager
1.1. Fjernelse af Array-element efter værdi ved hjælp af .splice ()
| På stedet: Ja |
| Fjerner dubletter: Ja (loop), Nej (indexOf) |
| Efter værdi / indeks: Efter indeks |
Hvis du kender den værdi, du vil fjerne fra et array, kan du bruge splejsningsmetoden. Først skal du identificere indekset for målelementet. Du bruger derefter indekset som startelement og fjerner kun et element.
// Med en 'for' løkke
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
for (lad i = 0; i  [1, 2, 3, 4, 6, 7, 8, 9, 0]
// Med .indexOf () -metoden
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
const i = arr.indexOf (5);
arr.splice (i, 1); // => [1, 2, 3, 4, 6, 7, 8, 9, 0]
1.2. Fjernelse af Array-element ved hjælp af .filter () -metoden
| På stedet: Nej |
| Fjerner dubletter: Ja |
| Efter værdi / indeks: Efter værdi |
Specifikt element kan filtreres fra array ved at give filtreringsfunktion. En sådan funktion kaldes derefter for hvert element i array.
const værdi = 3
lad arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (item => item! == værdi)
console.log (arr)
// [1, 2, 4, 5]
1.3. Fjernelse af Array-element ved at udvide Array.prototype
| På stedet: Ja / Nej (afhænger af implementering) |
| Fjerner dubletter: Ja / Nej (afhænger af implementering) |
| Efter værdi / indeks: Efter indeks / Efter værdi (afhænger af implementering) |
Prototype af Array kan udvides med yderligere metoder. Sådanne metoder vil derefter være tilgængelige til brug på oprettede arrays.
Bemærk: Udvidelse af prototyper af objekter fra JavaScript-standardbiblioteket (som Array) betragtes af nogle som et antipatron.
// På plads, fjerner alt ved implementering af værdi
Array.prototype.remove = funktion (element) {
for (lad i = 0; i  = ES10)
| På stedet: Nej |
| Fjerner dubletter: Ja |
| Efter værdi / indeks: Efter værdi |
ES10 introducerede Object.fromEntries, hvilket kan værebruges til at oprette ønsket array fra ethvert array-lignende objekt og filtrere uønskede elementer under processen.
const-objekt = [1,2,3,4];
const valueToRemove = 3;
const arr = Object.values ​​(Object.fromEntries (
Object.entries (objekt)
.filter (([key, val]) => val! == valueToRemove)
));
console.log (arr); // [1,2,4]
2. Særlige tilfælde
2.1 Fjernelse af elementet, hvis det er i slutningen af ​​Array
2.1.1. Ændring af array længde
| På stedet: Ja |
| Fjerner dubletter: Nej |
| Efter værdi / indeks: Ikke relevant |
JavaScript Array-elementer kan fjernes fra slutningen af ​​en matrix ved at indstille længdeegenskaben til en værdi, der er mindre end den aktuelle værdi. Ethvert element, hvis indeks er større end eller lig med den nye længde, fjernes.
const arr = [1, 2, 3, 4, 5, 6];
arr. længde = 5; // Indstil længde for at fjerne element
console.log (arr); // [1, 2, 3, 4, 5]
2.1.2. Brug af .pop () -metoden
| På stedet: Ja |
| Fjerner dubletter: Nej |
| Efter værdi / indeks: Ikke relevant |
Popmetoden fjerner det sidste element i arrayet, returnerer elementet og opdaterer længdeegenskaben. Pop-metoden ændrer det array, som det påberåbes på. Dette betyder, i modsætning til at bruge sletning, fjernes det sidste element fuldstændigt, og array-længden reduceres.
const arr = [1, 2, 3, 4, 5, 6];
arr.pop (); // returnerer 6
console.log (arr); // [1, 2, 3, 4, 5]
2.2. Fjerner element, hvis det er i begyndelsen af ​​Array
| På stedet: Ja |
| Fjerner dubletter: Nej |
| Efter værdi / indeks: Ikke relevant |
Metoden .shift () fungerer meget som popmetoden, bortset fra at den fjerner det første element i et JavaScript-array i stedet for det sidste. Når elementet fjernes, flyttes de resterende elementer ned.
const arr = [1, 2, 3, 4];
arr.skift (); // returnerer 1
console.log (arr); // [2, 3, 4]
2.3. Fjernelse af element, hvis det er det eneste element i matrixen
| På stedet: Ja |
| Fjerner dubletter: N / A |
| Efter værdi / indeks: Ikke relevant |
Den hurtigste teknik er at indstille en matrixvariabel til en tom matrix.
lad arr = [1];
arr = []; // tom matrix
Alternativt kan teknik fra 2.1.1 bruges ved at indstille længde til 0.
|
Du skal aldrig muteere dit array. Da dette er imod det funktionelle programmeringsmønster. Du kan oprette et nyt array uden at henvise til det array, du vil ændre data for ved hjælp af ECMAScript 6-metodefilteret;
var myArray = [1, 2, 3, 4, 5, 6];
Antag at du vil fjerne 5 fra arrayet, du kan simpelthen gøre det sådan:
myArray = myArray.filter (værdi => værdi! == 5);
Dette giver dig et nyt array uden den værdi, du ønskede at fjerne. Så resultatet bliver:
[1, 2, 3, 4, 6]; // 5 er fjernet fra denne matrix
For yderligere forståelse kan du læse MDN-dokumentationen på Array.filter.
|
En mere moderne, ECMAScript 2015 (tidligere kendt som Harmony eller ES 6) tilgang. Givet:
const items = [1, 2, 3, 4];
const index = 2;
Derefter:
items.filter ((x, i) => i! == indeks);
Hvilket giver:
[1, 2, 4]
Du kan bruge Babel og en polyfill-tjeneste for at sikre, at dette understøttes godt i alle browsere.
|
Du kan lave en bagudsløjfe for at sikre dig, at du ikke skruer indekserne op, hvis der er flere forekomster af elementet.
var myElement = "chokolade";
var myArray = ['chokolade', 'poptart', 'poptart', 'poptart', 'chokolade', 'poptart', 'poptart', 'chokolade'];
/ * Vigtig kode * /
for (var i = myArray.length - 1; i> = 0; i--) {
hvis (myArray [i] == myElement) myArray.splice (i, 1);
}
console.log (myArray);
Live demo
|
Du har 1 til 9 i arrayet, og du vil fjerne 5. Brug nedenstående kode:
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var newNumberArray = numberArray.filter (m => {
returner m! == 5;
});
console.log ("ny matrix, 5 fjernet", newNumberArray);
Hvis du vil have flere værdier. Eksempel: - 1,7,8
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var newNumberArray = numberArray.filter (m => {
returnere (m! == 1) && (m! == 7) && (m! == 8);
});
console.log ("ny matrix, 1,7 og 8 fjernet", newNumberArray);
Hvis du vil fjerne en matrixværdi i en matrix. Eksempel: [3,4,5]
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var removebleArray = [3,4,5];
var newNumberArray = numberArray.filter (m => {
returner! removebleArray.includes (m);
});
console.log ("ny Array, [3,4,5] fjernet", newNumberArray);
Inkluderer understøttet browser er link.
|
1
2
3
4
Næste
Meget aktivt spørgsmål. Optjen 10 omdømme for at besvare dette spørgsmål. Omdømmekravet hjælper med at beskytte dette spørgsmål mod spam og ikke-svar-aktivitet.
Er det ikke det svar, du leder efter? Gennemse andre spørgsmål, der er tagget javascript-arrays, eller stil dit eget spørgsmål.